# 1.1 AI Agent 是什么？

> **Week 1 | Lesson 1.1 | 45 分钟**

---

## 学习目标

完成本课后，你将能够：

- 说出 AI Agent 的四个核心组件
- 区分传统聊天模式与 Agent 模式的行为差异
- 理解 Agent 如何自主调用工具完成任务
- 运行一个简单的 Python 示例，感受 Agent 的工作方式

---

## 从 ChatGPT 到 AI Agent：一次范式转变

2022 年底，ChatGPT 横空出世。你可以跟它对话、问问题、让它写代码。但它的行为有一个根本限制：**你说一句，它回一句**。它不会主动去查资料、不会操作其他软件、不会把一个复杂任务拆成几步自己干完。

AI Agent 改变了这一点。

### 对比：聊天 vs Agent

| 维度 | 传统聊天（ChatGPT） | AI Agent |
|------|---------------------|----------|
| 主动性 | 被动响应，你说它答 | 主动规划，拆解任务 |
| 工具使用 | 只能用训练数据中的知识 | 可以调用搜索引擎、读文件、执行代码 |
| 记忆 | 限于当前对话窗口 | 可以持久化记忆，跨会话保留信息 |
| 决策 | 没有决策能力 | 根据结果自主决定下一步 |
| 任务完成 | 给出建议，你来执行 | 自己执行，返回结果 |

### 一个具体例子

**任务：查一下 2025 年诺贝尔物理学奖得主是谁，然后用中文写一段 100 字以内的简介。**

- **传统聊天模式**：模型会根据训练数据回答。如果训练数据截止日期之前没有这个信息，它会说"我不知道"。它不会去网上查。

- **Agent 模式**：
  1. 收到任务
  2. 判断"我不知道最新信息，需要搜索"
  3. 调用搜索工具，查到结果
  4. 读取搜索结果
  5. 根据结果撰写简介
  6. 返回最终答案

关键区别：**Agent 会自己决定"我需要什么工具"，然后去用它。**

---

## AI Agent 的四个核心组件

一个 AI Agent = **LLM + Memory + Tools + Autonomous Decision**

```
                    ┌─────────────┐
                    │    LLM      │  ← 大脑：理解、推理、生成
                    │  (大语言模型) │
                    └──────┬──────┘
                           │
          ┌────────────────┼────────────────┐
          ▼                ▼                ▼
   ┌─────────────┐  ┌─────────────┐  ┌─────────────┐
   │   Memory    │  │   Tools     │  │  Decision   │
   │   (记忆)     │  │   (工具)     │  │  (自主决策)  │
   └─────────────┘  └─────────────┘  └─────────────┘
```

### 1. LLM（大语言模型）—— 大脑

LLM 是 Agent 的核心推理引擎。它负责：
- 理解用户的自然语言指令
- 规划任务步骤
- 决定调用哪个工具
- 整合工具返回的结果，生成最终回答

常见的 LLM：
- OpenAI GPT 系列（GPT-4o、GPT-4o-mini）
- Claude 系列（Sonnet、Opus）
- 开源模型（Llama 3、Qwen 2.5）—— 可通过 Ollama 本地运行

### 2. Memory（记忆）—— 经验

Memory 让 Agent 不是一只"金鱼"。它包括：
- **短期记忆**：当前对话的上下文
- **长期记忆**：持久化存储的关键信息（向量数据库、文件等）

```python
# 简单的记忆示例：Agent 记住用户的偏好
memory = {
    "user_name": "张三",
    "preferred_language": "中文",
    "last_queries": [
        "2025年诺贝尔物理学奖",
        "Python 异步编程最佳实践"
    ]
}

# Agent 可以根据记忆个性化回答
def greet_agent(memory):
    name = memory.get("user_name", "用户")
    return f"你好 {name}，有什么可以帮你的？"
```

### 3. Tools（工具）—— 手脚

Tools 是 Agent 与外部世界交互的接口。常见的工具类型：

| 工具类型 | 用途 | 示例 |
|----------|------|------|
| 搜索工具 | 获取实时信息 | Google Search API, Tavily |
| 文件操作 | 读写本地文件 | `open()`, `pathlib` |
| 代码执行 | 运行 Python 代码 | Python REPL |
| API 调用 | 访问外部服务 | HTTP 请求、天气 API |
| 数据库 | 查询和存储数据 | SQLite, PostgreSQL |

```python
# 一个简单的工具函数示例
def search_web(query: str) -> str:
    """搜索网络并返回摘要结果"""
    # 这里模拟搜索工具
    results = {
        "Python": "Python 是一种高级编程语言，由 Guido van Rossum 于 1991 年发布",
        "HTTP": "HTTP 是超文本传输协议，用于 Web 浏览器和服务器之间的通信"
    }
    return results.get(query, f"未找到关于 '{query}' 的结果")

# 工具可以被 Agent 调用
print(search_web("Python"))
# 输出: Python 是一种高级编程语言，由 Guido van Rossum 于 1991 年发布
```

### 4. Autonomous Decision（自主决策）—— 灵魂

这是 Agent 区别于普通聊天机器人的核心。自主决策意味着：

```python
# 传统聊天：直接回答
def chat_response(question):
    return llm.generate(question)  # 只有一种路径

# Agent 模式：先判断，再行动
def agent_response(question):
    # 第一步：判断是否需要外部信息
    plan = llm.analyze(question)

    if plan.needs_search:
        # 第二步：自主决定使用搜索工具
        results = search_web(plan.search_query)
        # 第三步：整合结果生成回答
        return llm.generate(question, context=results)
    else:
        # 不需要工具，直接回答
        return llm.generate(question)
```

Agent 的决策循环（ReAct 模式）：

```
思考 (Thought) → 行动 (Action) → 观察 (Observation) → 再思考 → ... → 回答
```

---

## Agent 工作原理解析：一个完整流程

让我们用代码展示一个简化版 Agent 的完整工作流程：

```python
import json

class SimpleAgent:
    """一个极简的 AI Agent 实现"""

    def __init__(self):
        # 工具注册表：Agent 知道自己有哪些工具可用
        self.tools = {
            "calculator": self._calculator,
            "search": self._search,
            "greet": self._greet,
        }
        # 短期记忆
        self.memory = []

    def _calculator(self, expression: str) -> str:
        """工具1：计算器"""
        try:
            # 注意：生产环境不要用 eval，这里仅做演示
            result = eval(expression)
            return f"计算结果: {result}"
        except Exception as e:
            return f"计算错误: {e}"

    def _search(self, query: str) -> str:
        """工具2：模拟搜索"""
        knowledge_base = {
            "Python": "Python 是一种高级编程语言，1991 年发布，以简洁优雅著称",
            "AI": "人工智能（AI）是让机器模拟人类智能的技术",
            "Agent": "AI Agent 是能自主使用工具完成任务的智能体",
        }
        for key, value in knowledge_base.items():
            if key.lower() in query.lower():
                return value
        return f"未找到关于 '{query}' 的信息"

    def _greet(self, name: str) -> str:
        """工具3：问候"""
        return f"你好，{name}！欢迎使用 AI Agent！"

    def run(self, user_input: str) -> str:
        """
        Agent 的主循环：
        1. 分析用户输入
        2. 判断需要哪个工具
        3. 调用工具
        4. 返回结果
        """
        # 记录到记忆
        self.memory.append({"role": "user", "content": user_input})

        # --- 决策阶段：判断使用哪个工具 ---
        lower_input = user_input.lower()

        if any(word in lower_input for word in ["计算", "算一下", "+", "-", "*", "/"]):
            tool_name = "calculator"
            # 提取计算表达式
            import re
            expr = re.search(r'[\d\s\+\-\*\/\.\(\)]+', user_input)
            tool_input = expr.group(0) if expr else "0"
        elif any(word in lower_input for word in ["什么是", "查一下", "搜索", "告诉我不"]):
            tool_name = "search"
            tool_input = user_input
        elif any(word in lower_input for word in ["你好", "hi", "hello", "嗨"]):
            tool_name = "greet"
            tool_input = "朋友"
        else:
            # 没有匹配的工具，直接回答
            return "我还在学习新技能，暂时只能帮你计算、搜索或打招呼。"

        # --- 执行阶段：调用工具 ---
        print(f"[Agent 思考] 我需要使用工具: {tool_name}")
        tool_result = self.tools[tool_name](tool_input)
        print(f"[Agent 执行] 工具返回: {tool_result}")

        # 记录结果到记忆
        self.memory.append({"role": "assistant", "content": tool_result})

        return tool_result


# ========== 运行示例 ==========
if __name__ == "__main__":
    agent = SimpleAgent()

    print("=" * 60)
    print("AI Agent 演示")
    print("=" * 60)

    # 测试 1：使用计算器工具
    print("\n--- 测试 1：计算 ---")
    user_question = "帮我计算 23 * 45 + 100"
    print(f"用户: {user_question}")
    result = agent.run(user_question)
    print(f"Agent: {result}")

    # 测试 2：使用搜索工具
    print("\n--- 测试 2：搜索 ---")
    user_question = "什么是 AI Agent？"
    print(f"用户: {user_question}")
    result = agent.run(user_question)
    print(f"Agent: {result}")

    # 测试 3：使用问候工具
    print("\n--- 测试 3：问候 ---")
    user_question = "你好！"
    print(f"用户: {user_question}")
    result = agent.run(user_question)
    print(f"Agent: {result}")

    # 测试 4：没有匹配的工具
    print("\n--- 测试 4：未知请求 ---")
    user_question = "帮我画一幅画"
    print(f"用户: {user_question}")
    result = agent.run(user_question)
    print(f"Agent: {result}")
```

**运行输出：**

```
============================================================
AI Agent 演示
============================================================

--- 测试 1：计算 ---
用户: 帮我计算 23 * 45 + 100
[Agent 思考] 我需要使用工具: calculator
[Agent 执行] 工具返回: 计算结果: 1135
Agent: 计算结果: 1135

--- 测试 2：搜索 ---
用户: 什么是 AI Agent？
[Agent 思考] 我需要使用工具: search
[Agent 执行] 工具返回: AI Agent 是能自主使用工具完成任务的智能体
Agent: AI Agent 是能自主使用工具完成任务的智能体

--- 测试 3：问候 ---
用户: 你好！
[Agent 思考] 我需要使用工具: greet
[Agent 执行] 工具返回: 你好，朋友！欢迎使用 AI Agent！
Agent: 你好，朋友！欢迎使用 AI Agent！

--- 测试 4：未知请求 ---
用户: 帮我画一幅画
Agent: 我还在学习新技能，暂时只能帮你计算、搜索或打招呼。
```

注意看这个流程：Agent **先思考**需要哪个工具，**再执行**，**最后返回**结果。这就是与传统聊天最本质的区别。

---

## 主流 Agent 框架

在实际开发中，我们通常不会从零手写 Agent，而是使用成熟的框架。以下是当前最主流的选择：

| 框架 | 特点 | 适合场景 |
|------|------|----------|
| **LangGraph** | 基于状态机的图结构，流程可控 | 需要精确控制 Agent 流程 |
| **OpenAI Agents SDK** | OpenAI 官方出品，轻量易用 | OpenAI 模型 + 简单 Agent |
| **CrewAI** | 多 Agent 协作，角色扮演 | 需要多个 Agent 协同工作 |
| **AutoGen** | 微软出品，多 Agent 对话 | 复杂的多 Agent 场景 |
| **LlamaIndex** | 专注 RAG（检索增强生成） | 知识库问答场景 |

本课程主要使用 **OpenAI Agents SDK** 和 **Ollama** 作为开发工具，因为它们：
- 上手简单，代码量少
- 同时支持云端 API 和本地模型
- 社区活跃，文档丰富

---

## 动手练习

### 练习 1：扩展 Agent 的工具

在上面 `SimpleAgent` 的基础上，添加一个新的工具 `time_tool`，当用户问"现在几点"或"当前时间"时，返回当前系统时间。

提示代码：

```python
import datetime

def _get_time(self, _query: str) -> str:
    """工具：获取当前时间"""
    now = datetime.datetime.now()
    return f"当前时间是: {now.strftime('%Y年%m月%d日 %H:%M:%S')}"
```

### 练习 2：让 Agent 有记忆

修改 `SimpleAgent.run()` 方法，让 Agent 能引用之前的对话内容。例如：

```
用户: 你好！
Agent: 你好，朋友！欢迎使用 AI Agent！
用户: 我叫小明
Agent: 好的，我记住了，你叫小明。
用户: 我叫什么名字？
Agent: 你叫小明。
```

提示：可以在 `memory` 中查找用户的名字。

---

## 本节总结

- **AI Agent 不是更强的聊天机器人**，而是能自主使用工具完成任务的智能体
- **四个核心组件**缺一不可：LLM（大脑）、Memory（记忆）、Tools（工具）、Autonomous Decision（决策）
- Agent 的工作流程是循环的：**思考 -> 行动 -> 观察 -> 再思考**
- 与传统聊天的本质区别在于**主动性**和**工具使用能力**
- 实际开发中推荐使用成熟框架，本课程选用 **OpenAI Agents SDK** + **Ollama**

下一课，我们将搭建开发环境，让你的电脑具备运行 AI Agent 的能力。
